<?php

一：js可以书写在页面的任何位置，顺序执行，不能在title标签里， 区分大小写，换行和分号都是语句的结束。

1）<script src="./test.js"></script>
2）<a href="javascript:alert('javascript：alert')">javascript alert('')</a>
3）<a href="javascript://" onclick="alert('javascript://')">javascript://</a>
4）	<a href="#test" onclick="alert('弹出锚点#test')">#test</a>
	<a name="test"></a>
5）<script>alert('弹出的内容');</script>

二：例子
1）<script>
//输出内容，页面加载完成之后如果有再次执行就会覆盖原有的内容。
//一个再次执行按钮和相关的document.write函数，再次执行就会被覆盖
	document.write('aaaaaaaaaaaaaa<br>');
	document.write('aaaaaaaaaaaaaa<br>');
	document.write('aaaaaaaaaaaaaa<br>');
	document.write('aaaaaaaaaaaaaa<br>');
	function test(){
		document.write('重新输入');
	}
</script>
	<button onclick="test()">页面完成后再次执行会覆盖原来的document.write里的内容</button>

2）	//在窗口上显示鼠标坐标。
	document.onmousemove = function(e){
		document.title = 'X'+e.clientX+'	'+'Y'+e.clientY;
	}

3）//更改窗口的标题
	document.title = '浏览器的标题标题';

4）//获取元素由id
	<div id="div">div里面的蚊子</div>
	<script>
		div = document.getElementById('div');
		div.style.width = '300px';
		div.style.height = '300px';
		div.style.background = 'green';
		div.style.color = 'red';
	</script>

5）//变量的声明，不适用 $
	var a,b;
	a = 5;
	b = 7;

	var a;
	var b = 'test';

	var 变量 = '中文的变量';
	alert('变量');
	alert(变量);

6）//运算符
         +  +=   这个+充当两个身份  一个是 数值相加   一个是字符串拼接
         if(){}else if(){}else if(){}else{}
         ? :		三元运算符
        switch(a) 结构  case的值   类型严格匹配（）
		          var a = '10';			//这里有引号，下面的case值也要有引号，值要严格匹配。
		        switch(a){
		            case 5:
		                alert('N');
		                break;
		            case 10:
		                alert('Y');
		        }


7）//定时器：（延迟器）
	A====【 setTimeout()	clearTimeout()	】		在一段特定的时间后执行一次程序并结束。
		[定时器对象名=] setTimeout(“<表达式>”，毫秒)	
		实例
				[定时器对象名=] setTimeout(function(){}，毫秒)

		clearTimeout()：终止（清除）定时器 
			clearTimeout(定时器对象名)

	B====【  setInterval()	  clearInterval()】		重复执行<表达式>，直至窗口、框架被关闭或执行clearInterval。
		setInterval()：
		[定时器对象名=] setInterval(“<表达式>”，毫秒)

		clearInterval()：终止定时器 
		clearInterval(定时器对象名)


8）   ①		单双引号 在js里面没有区别 
	  ②		都不解析变量
	  ③		都解析转义字符
	  ④	 	不能自插  只能互插

	  字符串拼接变量
		       var a = 10;
			var str = 'ddddd' + a + 'bfff';
			alert(str);

9）
	<p id="my">原消息内容</p>
	<script>
		var my = document.getElementById('my');		//加引号
		//alert(my.innerHTML);
		my.innerHTML = "改变之后的内容";				//是等号
	</script>

10）
	strVariable.substring(start, end)
	substring 方法将返回一个包含从 start 到最后（不包含 end ）的子字符串的字符串。

	substr 方法			返回一个从指定位置开始的指定长度的子字符串。
	stringvar.substr(start [, length ])

11)		float类型不能参与运算，值不精确
		数值除以字符串得到的是NaN，NaN与数值型运算结果还是NaN，NaN不等于NaN，判断是不是NaN用isNa()
		被除数为0，结果是，Infinity,无穷大。
	//	parseInt 方法			返回由字符串转换得到的整数。
	//	parseFloat 方法			返回由字符串转换得到的浮点数。 

12)	
	 var arr = [];
        var arr = ['a','b','c','d'];
        arr[6] = 'test';

        var arr1 = new Array();       //定义一个空数组
        var arr1 = new Array(5);      //定义一个长度为5的数组
        var arr1 = new Array(5,6,7,8);  //将几个参数作为元素的数组
        var arr1 = new Array('5');			//5

        //alert(typeof arr1[0]);

        var obj = {};
        var obj = {a:'test',b:18};
        var obj = new Object(true);

        var bool = true;
        alert(typeof bool);

	var obj = {};
	alert(typeof obj);		//	object

	var obj = null;
	alert(typeof obj);		//	object

	var obj = undefined;
	alert(typeof obj);		//	undefined

	var  obj= 
	alert(typeof obj);		//	undefined

	//函数类型
	function test(){}
	var test = function(){};	
	var test = new Function();
	不传参数，则产生一个空数组，
	传一个参数，这个参数作为函数体，
	多个参数，前面的所有单数作为形参（凡在小括号里），最后一个参数作为函数体放在花括号里	
	<button onclick="test()">ceshi</button>
	<script>
	function test(){
		alert(1);
		return 'show';
	}
	test();
	alert(test);	
	var str = test();
	str;
	//函数的使用
	①		直接使用
	②		在表达式里面使用
	③		实践中绑定
	</script>

	var str = 'lamp';
	var newstr = (str.toUpperCase());
	alert(str);		//lamp
	alert(newstr);	//LAMP		toUpperCase()		字符转换为大写
	var arr = [5,3,7,9,3,1];
	alert(arr);		//	5,3,7,9,3,1
	var newarr = arr.sort();
	alert(arr);		//	1,3,3,5,7,9
	alert(newarr);	//	1,3,3,5,7,9
	alert(arr);		//	1,3,3,5,7,9
	str是一种数据类型，使用的对象时对应的String（包装）兑现g
	arr 本身就是一个对象，那么使用的时候就是修改自己
	对象的传参都是引用传递

	//js 常量， 字面量，就是值
	var a = 'test';

13）
        变量的作用域
	        全局变量
	        定义：  1.在函数体外面定义（加不加var都可以）   2.在函数体内定义（不能加var）
	        局部变量
	        定义：  1.在函数体内使用var关键字定义
	        	提前声明：
		           局部变量的作用范围是整个函数体，如果声明在下面，等同于在函数的第一行使用var 定义了一个局部变量（提前声明）
	            提前声明   （只是声明，赋值并没有提前，所以我们的25行是undefined）

	       function test(){
            局部变量的作用范围是整个函数体，如果声明在下面，等同于在函数的第一行使用var 定义了一个局部变量（提前声明）
            提前声明   （只是声明，赋值并没有提前，所以我们的25行是undefined）
            //var a;
            alert(typeof a);       //undefined
            var a = 20;
            alert(a);              //20
        }

14）
	var a = 10;
	alert(a);
	重新声明变量，不会覆盖原有的值，等同于无效
	var a;
	alert(a);

15）
	能使用局部变量的地方一定不要使用全局变量
	变量的优先级，局部>形参>全局

	实参如果少于形参，那么后面的没有实参的形参就是undefined
	实参多余形参，多余的实参会被舍弃

	function test(a,b){
		if(a == undefined) a = 10;
		if(b == undefined) b = 5;
		alert(a+b);
	}
	test();
	test(12,3);

16）
        //7种函数
        /*
        setInterval(function(){
            //这里用到了匿名和回调
        },50);
        */

        /*
        function test(num){
            document.write(num);
            if(num > 0){
                test(num-1);
            }
            document.write(num);
        }

        test(5);
        */

        /*
        //递归的使用场景
        function login(){
            var msg = prompt('请输入用户名','SB250');
            if(msg == '我是个傻X'){
                alert('亲！你太诚实了！！');
            }else{
                login();   
            }
        }
        login();
        */

        
        /*
        var test = function(){
            alert(1);
            return function(){
                alert(3);
            }
        }
        */


        /* 
        //自调函数是定义好之后，立即调用一次
        //如果前面出现了匿名函数，那么自调函数的第一个小括号会将上面的匿名函数调用一次，第二个小括号会将第一次调用的返回值当作函数调用，如果第一个返回的不是函数，那么报错！！
        //我们建议，匿名函数不要和自调函数出现在同一个文件中
        (function(a){
            alert(a);
        })('hello');
        */

        /*
        //返回函数的函数
        function test(){
            alert(1);
            return function(){
                alert(2);
            }
        }

        var a = test();
        a();
        */

        /*
        //能够重写自己的函数
        function a(){
            alert('我在这做了很多事情');
            a = function(){
                alert('你已经干过我一次了');
            }
        }

        a();
        a();
        */

        /*
        //构造函数
        function Person(name,age){
            this.name = name;
            this.age = age;

            this.say = function(){
                alert('我在喊话');
            }
        }

        var p1 = new Person('aaa',18);
        p1.say();
        */

        


17）
        //函数的闭包

        /*
        //闭包#1
        function A(){
            var a = 10;
            return function(){
                a++;
                alert(a);
            }
        }

        var a = A();

        a();
        a();
        */

        /*
        //闭包#2
        var a;
        function A(){
            var b = 10;
            a = function(){
                b++;
                alert(b);
            }
        }
        
        A();
        a();
        a();
        */

        /*
        //在循环中使用闭包
        function A(){
            var a = [];

            for(var i = 0;i<3;i++){
                a[i] = function(){
                    alert(i);
                }
            }

            return a;
        }

        var a = A();
        a[0]();
        a[1]();
        a[2]();
        */

        /*
        function A(){
            var a = [];
            for(var i=0; i<3; i++){
                a[i] = (function(x){
                    return function(){
                        alert(x);
                    }
                })(i)
            }
            return a;
        }

        var a = A();
        a[0]();
        a[1]();
        a[2]();
        */

        //和上面一样，将自调改造成了人工调用
        function A(){
            var a = [];

            function son(num){
                return function(){
                    alert(num);
                }
            }

            for(var i=0;i<3;i++){
                a[i] = son(i);
            }

            return a;
        }

        var a = A();
        a[0]();
        a[1]();
        a[2]();

18）

        //全局对象
        // alert   NaN   parseInt  parseFloat  eval   escape  unescape

        var str = '[1,2,3,4,5,65]';
        //var str = '{"name":"\u5c0f\u4e3d","age":18}';
        var arr =eval('('+str+')');
        alert(arr[2]);

19）
        //包装对象
        var str = 'hello';

        str.len = 10;      //这里产生了一个对象(包装对象 String)

        str.toUpperCase();

        alert(typeof str.len);
        
20）
	    //扩展系统内建对象
        /*
        //alert(typeof String.prototype);
        String.prototype.test = function(){
            alert(1);
        }

        String.prototype.name = 'ceshi';

        var str = 'hello';

        alert(str.name);
        */

        /*
        String.prototype.daozhuan = function(){
            return this.split('').reverse().join('');
        }

        var str = 'hello';
        alert(str.daozhuan());

        var str1 = new String('good');
        alert(str1.daozhuan());
        */

        Array.prototype.inArray = function(key){
            for(var i=0;i<this.length;i++){
                if(this[i] === key){
                    return true;
                }
            }
            return false;
        }

        var arr = [1,2,3,4,5,6];
        alert(arr.inArray(7));

21）

var newwin = window.open('','','width=300,height=300');
 newwin.moveBy(x,y);相对当前位置，每次移动多少，参数是  x,y坐标
   newwin.moveTo(x,y);    移动到制定坐标
           
22）
    // resizeTo(300,300);
    // moveTo(0,0);
    /*
    针对浏览器的body体顶点
    
    IE
    alert(window.screenLeft);   //  当前窗口的X坐标
    alert(window.screenTop);    //  单签窗口的Y坐标

    火狐
    window.screenX      //  当前窗口的X坐标
    window.screenY  //  单签窗口的Y坐标
    */
    
    // 屏幕尺寸  screen对象
    //screen.height     //  屏幕高度
    //screen.width      //  屏幕宽度

         <a href="http://localhost" onclick="return confirm('数据无价！谨慎操作')">本机</a>
        <a href="http://localhost" onclick="return show()">本机1</a>
        <a href="javascript:;" onclick="location.reload()">刷新</a>
        ar msg = prompt('请输入用户名','这里是默认值');

         //location.href = '';      将页面跳转到制定页面
        //location.reload()        刷新当前页

                //navigator 对象   只要记得 userAgent属性即可
        //可以配合字符串查找，判断浏览器是不是IE
        //alert(navigator.appName);
        //alert(navigator.appVersion);
        var str = navigator.userAgent;

        //document.write(str);
        var mask = str.indexOf('MSIE');

        /*
        if(mask < 0){
            alert('我是标准的');
        }else{
            alert(IE);
        }

        属性：
    length          返回浏览器历史列表中的 URL 数量。
 方法
    back()          加载 history 列表中的前一个 URL。
    forward()       加载 history 列表中的下一个 URL。
    go()            加载 history 列表中的某个具体页面。 
*/
23）
        三组属性
         offset   offsetLeft  offsetTop   offsetHeight  offsetWidth
         client   clientLeft  clientTop   clientHeight  clientWidth
         scroll   scrollLeft  scrollTop   scrollHeight  scrollWidth
24）
    IE中有效
    onload 加载完成   onunload 页面关闭之前    onbeforeunload 页面关闭之后

 <div id="div"></div>
<script>
    var div = document.getElementById('div');
    div.onclick = function(e){
        var e = e || event
        alert(e.clientX);
    }
</script>

25）
<div id="div">
    <div id="sdiv"></div>
</div>
<font id="font" size="15" color="red"></font>
<script>
    var div = document.getElementById('div');
    var font = document.getElementById('font');
    /*
    div.onmouseout = function(){
        font.innerHTML = '鼠标出来了';
    }
    div.onmouseover = function(){
        font.innerHTML = '鼠标进来了';
    }
    */
    div.onmouseenter = function(){
        font.innerHTML = '鼠标进进来了';
    }
    div.onmouseleave = function(){
        font.innerHTML = '鼠标出出去了';
    }
26）
27）
28）
29）